const { api } = require('../../../utils/api.js');
const logger = require('../../../utils/logger.js');

Page({
  data: {
    orders: [],
    loading: true,
    userId: null,
    statusBarHeight: 20 // 默认状态栏高度
  },

  onLoad: function (options) {
    // 获取系统状态栏高度
    const systemInfo = wx.getSystemInfoSync();
    this.setData({
      statusBarHeight: systemInfo.statusBarHeight || 20
    });
    
    // 获取当前登录用户ID
    const userInfo = wx.getStorageSync('userInfo');
    if (userInfo) {
      this.setData({
        userId: userInfo.userId
      });
    }
    this.getOrderList();
  },

  onShow: function () {
    // 每次页面显示时刷新数据
    this.refreshOrderList();
    
    // 添加延时强制刷新，解决可能的渲染问题
    setTimeout(() => {
      console.log('延时强制刷新订单数据');
      const currentOrders = this.data.orders || [];
      
      // 强制更新所有订单的格式化字段
      const refreshedOrders = currentOrders.map(order => {
        return {
          ...order,
          _formattedPaymentTime: this.formatDateTime(order.paymentTime),
          _formattedPaymentMethod: this.getPaymentMethodText(order.paymentMethod)
        };
      });
      
      // 如果有订单数据，强制更新
      if (refreshedOrders.length > 0) {
        console.log('强制更新订单数据:', refreshedOrders.length, '条');
        this.setData({
          orders: refreshedOrders,
          forceUpdate: Date.now()
        });
      }
    }, 800);
  },

  // 页面渲染完成后执行
  onReady: function() {
    // 延迟执行，确保DOM已经渲染
    setTimeout(() => {
      console.log('页面渲染完成，强制显示支付信息');
      try {
        // 尝试通过选择器获取所有支付信息元素
        const query = wx.createSelectorQuery();
        query.selectAll('.payment-time, .payment-method').fields({
          rect: true,
          computedStyle: ['display', 'visibility', 'height']
        }, (res) => {
          console.log('支付信息元素样式:', res);
          
          // 如果找到元素但不可见，重新渲染页面
          if (res && res.length > 0) {
            const hasInvisibleElement = res.some(item => 
              item.display === 'none' || 
              item.visibility === 'hidden' || 
              (item.height && parseInt(item.height) === 0)
            );
            
            if (hasInvisibleElement) {
              console.log('发现不可见的支付信息元素，强制重新渲染');
              // 强制刷新页面数据
              this.setData({
                forceUpdate: Date.now()
              });
            }
          }
        }).exec();
      } catch (err) {
        console.error('检查支付信息元素可见性失败:', err);
      }
    }, 500);
  },

  // 返回上一页
  goBack: function() {
    // 使用switchTab导航到"我的"页面
    wx.switchTab({
      url: '/pages/my/index'
    });
  },

  // 获取订单列表
  getOrderList: function () {
    this.setData({ loading: true });
    
    try {
      // 从本地存储获取订单数据
      const allOrders = wx.getStorageSync('orders') || [];
      logger.info('getOrderList', '获取到的全部订单: ' + allOrders.length);
      console.log('所有订单数据:', allOrders);
      
      // 筛选当前用户的订单
      let userOrders = [];
      if (this.data.userId) {
        userOrders = allOrders.filter(order => order.userId === this.data.userId);
        logger.info('getOrderList', `当前用户(${this.data.userId})订单数量: ${userOrders.length}`);
      } else {
        // 如果没有用户ID，则默认显示所有订单（开发模式）
        userOrders = allOrders;
        logger.info('getOrderList', '无用户ID，显示全部订单');
      }
      
      // 确保每个订单的字段都有效
      let hasChanges = false;
      userOrders.forEach(order => {
        // 价格处理
        if (!order.price) {
          order.price = 40.00; // 默认价格
          hasChanges = true;
        } else {
          order.price = parseFloat(order.price);
        }
        if (!order.totalAmount) {
          order.totalAmount = (order.price * (order.quantity || 1)).toFixed(2);
          hasChanges = true;
        } else {
          order.totalAmount = parseFloat(order.totalAmount).toFixed(2);
        }
        
        // 确保订单时间存在
        if (!order.orderTime) {
          // 如果没有订单时间，使用当前时间
          order.orderTime = new Date().getTime();
          console.log(`为订单 ${order.id} 添加默认下单时间`);
          hasChanges = true;
        }
        
        // 确保所有订单都有支付信息，无论状态如何
          // 如果缺少支付时间，添加默认值
          if (!order.paymentTime) {
            order.paymentTime = order.orderTime + (10 * 60 * 1000); // 默认下单后10分钟支付
          console.log(`为订单 ${order.id} 添加默认支付时间: ${new Date(order.paymentTime).toLocaleString()}`);
            hasChanges = true;
          } else {
            console.log(`订单 ${order.id} 已有支付时间: ${new Date(order.paymentTime).toLocaleString()}`);
            
            // 确保支付时间是数字类型
            if (typeof order.paymentTime === 'string') {
              const parsedTime = parseInt(order.paymentTime);
              if (!isNaN(parsedTime)) {
                order.paymentTime = parsedTime;
              } else {
                // 如果解析失败，使用下单时间加10分钟
                order.paymentTime = order.orderTime + 10 * 60 * 1000;
              }
              console.log(`修正订单 ${order.id} 支付时间类型: ${new Date(order.paymentTime).toLocaleString()}`);
              hasChanges = true;
            }
          }
          
          // 如果缺少支付方式，添加默认值
          if (!order.paymentMethod) {
            order.paymentMethod = 'wechat'; // 默认微信支付
          console.log(`为订单 ${order.id} 添加默认支付方式: 微信支付`);
            hasChanges = true;
          } else {
            console.log(`订单 ${order.id} 已有支付方式: ${order.paymentMethod}`);
          }
          
          // 强制确保关键支付字段存在
          if (typeof order.paymentTime === 'undefined' || order.paymentTime === null || isNaN(order.paymentTime)) {
            console.error(`订单 ${order.id} 支付时间字段异常，强制修复`);
            order.paymentTime = Date.now();
            hasChanges = true;
          }
          
          if (typeof order.paymentMethod === 'undefined' || order.paymentMethod === null || order.paymentMethod === '') {
            console.error(`订单 ${order.id} 支付方式字段异常，强制修复`);
            order.paymentMethod = 'wechat';
            hasChanges = true;
        }
        
        console.log(`处理订单 ${order.id}: 状态=${order.status}, 价格=${order.price}, 总额=${order.totalAmount}, 下单时间=${this.formatDateTime(order.orderTime)}`);
        
        // 打印支付信息，便于调试
          console.log(`订单 ${order.id} 支付信息: 方式=${this.getPaymentMethodText(order.paymentMethod)}, 时间=${this.formatDateTime(order.paymentTime)}`);
      });
      
      // 如果有订单信息被修改，更新存储
      if (hasChanges) {
        console.log('订单信息已更新，保存到本地存储');
        // 更新本地存储中的所有订单
        const ordersToSave = [...allOrders];
        
        // 更新修改过的订单
        userOrders.forEach(updatedOrder => {
          const index = ordersToSave.findIndex(o => o.id === updatedOrder.id);
          if (index >= 0) {
            ordersToSave[index] = updatedOrder;
          }
        });
        
        // 保存更新后的订单列表
        wx.setStorageSync('orders', ordersToSave);
      }
      
      // 按时间排序，最新订单在前
      userOrders.sort((a, b) => b.orderTime - a.orderTime);
      
      // 调试输出最终的订单数据
      userOrders.forEach(order => {
        console.log(`最终订单数据: ID=${order.id}, 状态=${order.status}, 支付方式=${order.paymentMethod}, 支付时间=${this.formatDateTime(order.paymentTime)}`);
      });
      
      // 最终处理：确保所有订单的支付信息都有效
      userOrders = userOrders.map(order => {
        // 深拷贝对象，避免引用问题
        const processedOrder = {...order};
        
        // 确保支付方式字段有效
        if (!processedOrder.paymentMethod || processedOrder.paymentMethod === '') {
          processedOrder.paymentMethod = 'wechat';
          console.log(`最终处理：为订单 ${processedOrder.id} 设置默认支付方式`);
        }
        
        // 确保支付时间字段有效
        if (!processedOrder.paymentTime || isNaN(processedOrder.paymentTime)) {
          processedOrder.paymentTime = processedOrder.orderTime || Date.now();
          console.log(`最终处理：为订单 ${processedOrder.id} 设置默认支付时间`);
        }
        
        // 确保支付时间是数字类型
        if (typeof processedOrder.paymentTime === 'string') {
          processedOrder.paymentTime = parseInt(processedOrder.paymentTime) || Date.now();
        }
        
        // 添加显式的格式化字段，便于模板直接使用
        processedOrder._formattedPaymentTime = this.formatDateTime(processedOrder.paymentTime);
        processedOrder._formattedPaymentMethod = this.getPaymentMethodText(processedOrder.paymentMethod);
        
        return processedOrder;
      });
      
      this.setData({
        orders: userOrders,
        loading: false
      });
      
      // 再次检查页面数据
      setTimeout(() => {
        console.log('页面数据检查:', this.data.orders.map(order => ({
          id: order.id,
          paymentMethod: order.paymentMethod,
          paymentTime: order.paymentTime,
          formattedPaymentTime: this.formatDateTime(order.paymentTime)
        })));
      }, 100);
      
    } catch (err) {
      logger.error('getOrderList', err);
      this.setData({ loading: false });
      
      wx.showToast({
        title: '获取订单失败',
        icon: 'none',
        duration: 2000
      });
    }
  },

  // 跳转到支付页面
  goPay: function(e) {
    const orderId = e.currentTarget.dataset.id;
    logger.info('goPay', `开始跳转支付页面，订单ID: ${orderId}`);
    
    // 先跳转到"我的"页面，再跳转到订单支付页
    wx.switchTab({
      url: '/pages/my/index',
      success: () => {
        logger.info('goPay', '成功跳转到我的页面');
        setTimeout(() => {
          const paymentUrl = `/pages/order/payment/index?orderId=${orderId}`;
          logger.info('goPay', `准备跳转到支付页面: ${paymentUrl}`);
          
          wx.navigateTo({
            url: paymentUrl,
            success: () => {
              logger.info('goPay', '成功跳转到支付页面');
            },
            fail: (err) => {
              logger.error('goPay', `跳转到支付页面失败: ${JSON.stringify(err)}`);
              wx.showToast({
                title: '跳转支付页面失败',
                icon: 'none',
                duration: 2000
              });
            }
          });
        }, 100);
      },
      fail: (err) => {
        logger.error('goPay', `跳转到我的页面失败: ${JSON.stringify(err)}`);
      }
    });
  },

  // 取消订单
  cancelOrder: function(e) {
    const orderId = e.currentTarget.dataset.id;
    
    wx.showModal({
      title: '确认取消',
      content: '确定要取消此订单吗？',
      success: (res) => {
        if (res.confirm) {
          // 从本地存储获取订单数据
          const allOrders = wx.getStorageSync('orders') || [];
          // 找到订单在数组中的索引
          const orderIndex = allOrders.findIndex(order => order.id === orderId);
          
          if (orderIndex >= 0) {
            // 直接从数组中删除该订单
            allOrders.splice(orderIndex, 1);
            wx.setStorageSync('orders', allOrders);
            
            // 刷新订单列表
            this.getOrderList();
            
            wx.showToast({
              title: '订单已取消',
              icon: 'success',
              duration: 2000
            });
          }
        }
      }
    });
  },

  // 查看订单详情
  viewOrderDetail: function (e) {
    const orderId = e.currentTarget.dataset.id;
    logger.info('viewOrderDetail', `开始查看订单详情，订单ID: ${orderId}`);
    
    // 直接跳转到订单详情页，添加from=detail参数标识来源
    const detailUrl = `/pages/order/payment/index?orderId=${orderId}&from=detail`;
    logger.info('viewOrderDetail', `准备跳转到订单详情页: ${detailUrl}`);
    
    wx.navigateTo({
      url: detailUrl,
      success: () => {
        logger.info('viewOrderDetail', '成功跳转到订单详情页');
      },
      fail: (err) => {
        logger.error('viewOrderDetail', `跳转到订单详情页失败: ${JSON.stringify(err)}`);
        
        // 如果直接跳转失败，先转到我的页面再跳转
        wx.switchTab({
          url: '/pages/my/index',
          success: () => {
            setTimeout(() => {
              wx.navigateTo({
                url: detailUrl
              });
            }, 100);
          }
        });
      }
    });
  },

  // 格式化日期时间
  formatDateTime: function (timestamp) {
    // 如果时间戳为空，使用当前时间
    if (!timestamp) {
      console.warn('formatDateTime: 传入的时间戳为空，使用当前时间');
      // 返回固定文本而不是当前时间
      return '支付完成';
    }
    
    try {
      // 处理字符串时间戳
      if (typeof timestamp === 'string') {
        timestamp = parseInt(timestamp);
      }
      
      const date = new Date(timestamp);
      if (isNaN(date.getTime())) {
        console.warn('formatDateTime: 无效的日期时间戳:', timestamp);
        return '支付完成';
      }
      
      const year = date.getFullYear();
      const month = (date.getMonth() + 1).toString().padStart(2, '0');
      const day = date.getDate().toString().padStart(2, '0');
      const hour = date.getHours().toString().padStart(2, '0');
      const minute = date.getMinutes().toString().padStart(2, '0');
      const second = date.getSeconds().toString().padStart(2, '0');
      
      return `${year}-${month}-${day} ${hour}:${minute}:${second}`;
    } catch (err) {
      console.error('格式化日期时间错误:', err, '时间戳:', timestamp);
      return '支付完成';
    }
  },

  // 格式化价格显示
  formatPrice: function (price) {
    if (!price || isNaN(price)) {
      return '0.00';
    }
    return parseFloat(price).toFixed(2);
  },

  // 获取订单状态文本
  getStatusText: function (status) {
    switch (status) {
      case 'pending':
        return '待支付';
      case 'paid':
        return '已支付';
      case 'canceled':
        return '已取消';
      default:
        return '未知状态';
    }
  },

  // 获取支付方式文本
  getPaymentMethodText: function (method) {
    // 如果方法为空，返回默认值
    if (!method || method === '') {
      console.warn('getPaymentMethodText: 支付方式为空，使用默认值');
      return '微信支付';
    }
    
    switch (method) {
      case 'wechat':
        return '微信支付';
      case 'alipay':
        return '支付宝';
      case 'creditcard':
        return '银行卡';
      default:
        console.warn('getPaymentMethodText: 未知的支付方式:', method);
        return '微信支付';
    }
  },
  
  // 下拉刷新
  onPullDownRefresh: function () {
    this.getOrderList();
    wx.stopPullDownRefresh();
  },
  
  // 强制刷新订单列表
  refreshOrderList: function() {
    console.log('强制刷新订单列表');
    // 清除缓存中的订单数据
    try {
      const allOrders = wx.getStorageSync('orders') || [];
      
      // 确保所有已支付订单有完整的支付信息
      let hasChanges = false;
      allOrders.forEach(order => {
        if (order.status === 'paid') {
          console.log(`检查订单 ${order.id} 的支付信息: 方式=${order.paymentMethod || '未知'}, 时间=${order.paymentTime ? new Date(order.paymentTime).toLocaleString() : '未知'}`);
          
          // 修复支付方式
          if (!order.paymentMethod) {
            order.paymentMethod = 'wechat';
            console.log(`修复订单 ${order.id} 的支付方式: 微信支付`);
            hasChanges = true;
          }
          
          // 修复支付时间
          if (!order.paymentTime) {
            if (order.orderTime) {
              // 下单后10分钟支付
              order.paymentTime = order.orderTime + 10 * 60 * 1000;
            } else {
              // 如果连订单时间都没有，默认为现在时间前一天
              const now = Date.now();
              order.orderTime = now - 24 * 60 * 60 * 1000;
              order.paymentTime = now - 23 * 60 * 60 * 1000;
            }
            console.log(`修复订单 ${order.id} 的支付时间: ${new Date(order.paymentTime).toLocaleString()}`);
            hasChanges = true;
          }
        }
      });
      
      if (hasChanges) {
        console.log('订单数据已修复，保存更新');
        wx.setStorageSync('orders', allOrders);
      }
    } catch (err) {
      console.error('刷新订单列表失败:', err);
    }
    
    // 重新获取订单列表
    setTimeout(() => {
      this.getOrderList();
    }, 100);
  }
}) 